List PatternsĀ¶

image.png

šŸ–Œ Transforming a ListĀ¶

transform_a_list.pyĀ¶

This demonstrates the mapping pattern.

Map is a mathematical term that means going from one value to a corresponding value.

This is also referred to as the transform pattern.

šŸ‘ØšŸ¼ā€šŸŽØ smaller_numbers.pyĀ¶

Write a function that creates a new list where each item has been divided by 2.

You can pass lists to functions and return lists from functions.

image.png

šŸ–Œ Filtering ListsĀ¶

only_odds.pyĀ¶

This demonstrates the filter pattern.

A new collection is created with certain items filtered out.

NOTES

  • Step through with debugger
  • Show how numbers are added only if they are odd

image.png

šŸ–Œ Selecting from a ListĀ¶

find_min.pyĀ¶

This demonstrates the selection pattern.

A single item is selected from a collection.

NOTES

  • is None: this is how you check if a variable points to None
  • Step through in debugger
  • Look at logic of if condition
    • See how the value of smallest updates only sometimes

image.png

šŸ–Œ AccumulationĀ¶

average.pyĀ¶

This demonstrates the accumulator pattern.

total accumulates the values in the collection.

NOTES

  • Step through in debugger
  • Show how total updates

image.png

šŸ‘©šŸ»ā€šŸŽØ All TogetherĀ¶

Given a list of numbers, write a function that substracts 7 and removes the negative numbers or numbers greater than 10.

all_together.pyĀ¶

Another way for list patternsĀ¶

InĀ [23]:
numbers = [1, 2, 3, 4, 5]

min, maxĀ¶

InĀ [4]:
min(numbers), max(numbers)
Out[4]:
(1, 5)

sumĀ¶

InĀ [2]:
sum(numbers)
Out[2]:
15
InĀ [3]:
sum(numbers) / len(numbers)
Out[3]:
3.0

List comprehensionsĀ¶

Mapping patternĀ¶

InĀ [5]:
new_numbers = []
for number in numbers:
    new_number = number + 7
    new_numbers.append(new_number)
new_numbers
Out[5]:
[8, 9, 10, 11, 12]
InĀ [6]:
new_numbers = [number + 7 for number in numbers]
new_numbers
Out[6]:
[8, 9, 10, 11, 12]
InĀ [7]:
def add_seven(number):
    return number + 7
new_numbers = [add_seven(number) for number in numbers]
new_numbers
Out[7]:
[8, 9, 10, 11, 12]
InĀ [10]:
[number // 3 for number in numbers]
Out[10]:
[0, 0, 1, 1, 1]
InĀ [11]:
[number ** 2 for number in numbers]
Out[11]:
[1, 4, 9, 16, 25]
InĀ [12]:
[number ** 0.5 for number in numbers]
Out[12]:
[1.0, 1.4142135623730951, 1.7320508075688772, 2.0, 2.23606797749979]

Filter patternĀ¶

InĀ [13]:
new_numbers = []
for number in numbers:
    if number > 3:
        new_numbers.append(number)
new_numbers
Out[13]:
[4, 5]
InĀ [14]:
numbers = [1, 2, 3, 4, 5]
InĀ [18]:
[number for number in numbers if number > 3]
Out[18]:
[4, 5]
InĀ [19]:
[number for number in numbers if number % 2 == 0]
Out[19]:
[2, 4]
InĀ [20]:
[number for number in numbers if number * 5 < 20]
Out[20]:
[1, 2, 3]

All Together with comprehensionsĀ¶

InĀ [22]:
nums = [0, 7, 2, 14, 20, 32, 5, 12]

# subtract 7
nums = [number - 7 for number in nums]

# Keep 0 <= num <= 10
def is_keeper(number):
    return 0 <= number <= 10

nums = [number for number in nums if is_keeper(number)]

print(nums)

[0, 7, 5]
InĀ [21]:
nums = [0, 7, 2, 14, 20, 32, 5, 12]
[number - 7 for number in nums if 0 <= number - 7 < 10]
Out[21]:
[0, 7, 5]

Key IdeasĀ¶

  • mapping pattern
  • filter pattern
  • selection pattern
  • accumulator pattern
  • List comprehensions
    • mapping pattern
    • filter pattern